from robyn import SubRouter
from services import role_service
from constants import HttpStatus, DefaultValues, Role
from middleware.auth_middleware import auth_required
from utils.error_handler import unified_response, get_error_response, handle_database_error
from datetime import datetime

import json
# 创建角色子路由器
# 所有角色相关的API端点都将以/roles为前缀
role_controller = SubRouter(__file__, prefix="/api/system/role")

@role_controller.post("/")
@auth_required() # Only admin can create roles
async def addRole(request):
    """
    创建新的角色
    
    HTTP方法: POST
    端点: /roles/
    认证: 需要管理员认证
    
    请求体:
        JSON格式的角色数据，包含角色名称和描述
    
    返回:
        成功: code=200, msg="Role added successfully", data=新创建的角色
        失败: code=500, msg="Failed to add role", error_info包含错误详情
    
    功能:
        - 接收JSON格式的角色数据
        - 调用服务层创建新的角色
        - 返回创建结果或错误信息
    
    错误处理:
        - 捕获所有异常并返回统一的错误响应
        - 支持调试模式下的详细错误信息
    """
    try:
        # 从请求体中获取JSON数据
        role_data = request.json()
        
        # 调用服务层创建角色
        newRole = role_service.createRole(role_data)
        
        # 检查创建结果
        if newRole is None:
            return unified_response(HttpStatus.INTERNAL_SERVER_ERROR, "Role not added", None)
        
        # 返回成功响应
        return unified_response(HttpStatus.OK, "Role added successfully", newRole)
    
    except Exception as e:
        # 捕获异常并返回错误响应
        return unified_response(HttpStatus.INTERNAL_SERVER_ERROR, "Failed to add role", None, error=e)

@role_controller.get("/list")
# @auth_required() # Only admin can get all roles
# async def getRoles(request):
#     """
#     获取角色列表（支持分页）
#
#     HTTP方法: GET
#     端点: /roles/
#     认证: 需要管理员认证
#
#     查询参数:
#         skip (int, optional): 跳过的记录数，默认为DefaultValues.SKIP
#         limit (int (int, optional): 返回的记录数，默认为DefaultValues.LIMIT
#
#     返回:
#         成功: code=200, msg="Roles retrieved successfully", data=角色列表
#         失败: code=500, msg="Failed to retrieve roles", error_info包含错误详情
#
#     功能:
#         - 支持分页查询，通过skip和limit参数控制
#         - 调用服务层获取角色列表
#         - 返回查询结果或错误信息
#
#     参数处理:
#         - skip参数默认为DefaultValues.SKIP，转换为整数
#         - limit参数默认为DefaultValues.LIMIT，转换为整数
#
#     错误处理:
#         - 捕获参数转换异常
#         - 捕获服务层异常并返回统一的错误响应
#     """
#     try:
#         # 获取并转换分页参数（兼容前端格式）
#         page = int(request.query_params.get("page", "1"))
#         page_size = int(request.query_params.get("pageSize", "20"))
#
#         # 计算skip值
#         skip = (page - 1) * page_size
#         limit = page_size
#         # # 获取并转换分页参数
#         # skip = int(request.query_params.get("skip", DefaultValues.SKIP))
#         # limit = int(request.query_params.get("limit", DefaultValues.LIMIT))
#
#         # 调用服务层获取角色列表
#         roles = role_service.getRoles(skip=skip, limit=limit)
#
#         # 返回成功响应
#         return unified_response(HttpStatus.OK, "Roles retrieved successfully", roles)
#
#     except Exception as e:
#         # 捕获异常并返回错误响应
#         return unified_response(HttpStatus.INTERNAL_SERVER_ERROR, "Failed to retrieve roles", None, error=e)
async def getSystemRoleList(request):
    """
    获取系统角色列表（支持分页和过滤）- 前端系统管理界面专用
    返回符合SystemRoleApi.SystemRole接口格式的数据

    HTTP方法: GET
    端点: /api/system/role/list
    认证: 需要管理员认证

    查询参数:
        page (int, optional): 页码，默认为1
        pageSize (int, optional): 每页记录数，默认为20
        roleName (str, optional): 角色名称，用于模糊查询
        status (str, optional): 角色状态
        id (str, optional): 角色ID，用于精确查询
        remark (str, optional): 备注信息，用于模糊查询
        createTimeStart (str, optional): 创建时间开始范围 (格式: YYYY-MM-DD)
        createTimeEnd (str, optional): 创建时间结束范围 (格式: YYYY-MM-DD)

    返回格式:
        {
          "items": [
            {
              "id": "string", // 角色ID
              "name": "string", // 角色名称
              "roleCode": "string[]", // 权限ID数组
              "description": "string", // 描述
              "status": "number", // 状态 (0: 禁用, 1: 启用)
              "createTime": "string" // 创建时间 (例如: "2023-10-27 10:00:00")
            }
          ],
          "total": "number" // 总记录数
        }

    功能:
        - 支持分页查询，通过page和pageSize参数控制
        - 支持按角色名称和状态进行过滤
        - 兼容前端request-client.ts的调用格式
        - 返回SystemRoleApi.SystemRole接口格式的数据
        - 包含权限ID数组

    参数处理:
        - page参数默认为1，转换为整数
        - pageSize参数默认为20，转换为整数
        - roleName、status、id、remark为可选字符串参数
        - createTimeStart和createTimeEnd为可选日期参数，格式为YYYY-MM-DD

    错误处理:
        - 捕获参数转换异常
        - 捕获服务层异常并返回统一的错误响应
    """
    try:
        # 获取分页参数
        page = int(request.query_params.get("page", "1"))
        page_size = int(request.query_params.get("pageSize", "20"))
        
        # 获取查询参数
        role_name = request.query_params.get("name", "")
        status = request.query_params.get("status", "")
        role_id = request.query_params.get("id", "")
        remark = request.query_params.get("remark", "")

        data_dict = json.loads(str(request.query_params))

        # 正确获取 createTime[] 数组参数
        create_time_array = data_dict.get("createTime[]", "")

        if not create_time_array:
            create_time_array = []  # 如果参数不存在或为空，设置为空列表
        elif isinstance(create_time_array, str):
            create_time_array = [create_time_array]  # 如果是字符串，转换为列表

        create_time_start = create_time_array[0] if len(create_time_array) > 0 else ""
        create_time_end = create_time_array[1] if len(create_time_array) > 1 else ""

        # 调用服务层获取角色列表和总数
        response_data = role_service.get_system_roles(
            page=page, 
            page_size=page_size, 
            role_name=role_name, 
            status=status,
            role_id=role_id,
            remark=remark,
            create_time_start=create_time_start,
            create_time_end=create_time_end
        )

        # 返回成功响应
        return unified_response(HttpStatus.OK, "Roles retrieved successfully", response_data)

    except Exception as e:
        # 捕获异常并返回错误响应
        return unified_response(HttpStatus.INTERNAL_SERVER_ERROR, "Failed to retrieve roles", None, error=e)


@role_controller.get("/:role_id")
@auth_required() # Only admin can get a single role
async def getRole(request):
    """
    根据ID获取单个角色
    
    HTTP方法: GET
    端点: /roles/{role_id}
    认证: 需要管理员认证
    
    路径参数:
        role_id: 角色的唯一标识符
    
    返回:
        成功且找到记录: code=200, msg="Role retrieved successfully", data=角色
        成功但未找到: code=404, msg="Role not found", data=None
        失败: code=500, msg="Failed to retrieve role", error_info包含错误详情
    
    功能:
        - 从路径参数中获取role_id
        - 调用服务层根据ID查询角色
        - 根据查询结果返回相应的响应
    
    参数处理:
        - 从request.path_params中获取role_id
    
    错误处理:
        - 处理记录不存在的情况（返回404）
        - 捕获服务层异常并返回统一的错误响应
    """
    try:
        # 从路径参数中获取角色ID
        role_id = request.path_params.get("role_id")
        
        # 调用服务层根据ID查询角色
        roleModel = role_service.getRole(role_id)
        
        # 检查查询结果
        if roleModel is None:
            # 记录不存在，返回404错误
            return unified_response(HttpStatus.NOT_FOUND, "Role not found", None)
        
        # 返回成功响应
        return unified_response(HttpStatus.OK, "Role retrieved successfully", roleModel)
    
    except Exception as e:
        # 捕获异常并返回错误响应
        return unified_response(HttpStatus.INTERNAL_SERVER_ERROR, "Failed to retrieve role", None, error=e)

@role_controller.put("/:role_id")
@auth_required() # Only admin can update roles
async def updateRole(request):
    """
    更新角色
    
    HTTP方法: PUT
    端点: /roles/{role_id}
    认证: 需要管理员认证
    
    路径参数:
        role_id: 要更新的角色的唯一标识符
    
    请求体:
        JSON格式的更新数据，包含需要修改的字段
    
    返回:
        成功且找到记录: code=200, msg="Role updated successfully", data=更新后的角色
        成功但未找到: code=404, msg="Role not found", data=None
        失败: code=500, msg="Failed to update role", error_info包含错误详情
    
    功能:
        - 从路径参数中获取role_id
        - 从请求体中获取更新数据
        - 调用服务层更新角色
        - 根据更新结果返回相应的响应
    
    参数处理:
        - 从request.path_params中获取role_id
        - 从request.json()中获取更新数据
    
    错误处理:
        - 处理记录不存在的情况（返回404）
        - 捕获服务层异常并返回统一的错误响应
    """
    try:
        # 从路径参数中获取角色ID
        role_id = request.path_params.get("role_id")
        
        # 从请求体中获取更新数据
        role_data = request.json()
        
        # 调用服务层更新角色
        updatedRole = role_service.updateRole(role_id, role_data)
        
        # 检查更新结果
        if updatedRole is None:
            # 记录不存在，返回404错误
            return unified_response(HttpStatus.NOT_FOUND, "Role not found", None)
        
        # 返回成功响应
        return unified_response(HttpStatus.OK, "Role updated successfully", updatedRole)
    
    except Exception as e:
        # 捕获异常并返回错误响应
        return unified_response(HttpStatus.INTERNAL_SERVER_ERROR, "Failed to update role", None, error=e)

@role_controller.delete("/:role_id")
@auth_required() # Only admin can delete roles
async def deleteRole(request):
    """
    删除角色
    
    HTTP方法: DELETE
    端点: /roles/{role_id}
    认证: 需要管理员认证
    
    路径参数:
        role_id: 要删除的角色的唯一标识符
    
    返回:
        成功且找到记录: code=200, msg="Role deleted successfully", data=None
        成功但未找到: code=404, msg="Role not found", data=None
        失败: code=500, msg="Failed to delete role", error_info包含错误详情
    
    功能:
        - 从路径参数中获取role_id
        - 调用服务层删除角色
        - 根据删除结果返回相应的响应
    
    参数处理:
        - 从request.path_params中获取role_id
    
    错误处理:
        - 处理记录不存在的情况（返回404）
        - 捕获服务层异常并返回统一的错误响应
    
    注意:
        - 删除操作是不可逆的，需要谨慎处理
        - 建议在实际应用中添加软删除机制
    """
    try:
        # 从路径参数中获取角色ID
        role_id = request.path_params.get("role_id")
        
        # 调用服务层删除角色
        isDeleted = role_service.deleteRole(role_id)
        
        # 检查删除结果
        if not isDeleted:
            # 记录不存在或删除失败，返回404错误
            return unified_response(HttpStatus.NOT_FOUND, "Role not found", None)
        
        # 返回成功响应
        return unified_response(HttpStatus.OK, "Role deleted successfully", None)
    
    except Exception as e:
        # 捕获异常并返回错误响应
        return unified_response(HttpStatus.INTERNAL_SERVER_ERROR, "Failed to delete role", None, error=e)


